#include <iostream>
#include <string>
#include <thread>
#include <mutex>
#include <chrono>

// 用于保护控制台输出的互斥锁
std::mutex cout_mutex;

// 跟踪活跃的文档数
int active_documents = 0;
std::mutex active_docs_mutex;

void print_message(const std::string& message) {
    std::lock_guard<std::mutex> lock(cout_mutex);
    std::cout << message << std::endl;
}

void open_document_and_display_gui(std::string const &filename) {
    {
        std::lock_guard<std::mutex> lock(active_docs_mutex);
        active_documents++;
    }
    print_message("打开文档: " + filename);
}

void close_document_gui(std::string const &filename) {
    {
        std::lock_guard<std::mutex> lock(active_docs_mutex);
        active_documents--;
    }
    print_message("关闭文档: " + filename);
}

// 修改枚举名称，避免与函数名冲突
enum command_type { open_new_document, close_current_document, process_text };

struct user_command {
    command_type type;
    std::string text;

    user_command(command_type t = open_new_document, const std::string& txt = "") 
        : type(t), text(txt) {}
};

// 模拟用户输入，每次返回不同的命令
user_command get_user_input(const std::string& current_doc) {
    // 随机决定下一个命令
    static int counter = 0;
    counter++;
    
    // 每3次操作打开一个新文档
    if (counter % 3 == 0) {
        return user_command(open_new_document);
    }
    // 每5次操作关闭当前文档
    else if (counter % 5 == 0) {
        return user_command(close_current_document);
    }
    // 其他情况模拟文本处理
    else {
        return user_command(process_text, "编辑 " + current_doc + " 的内容");
    }
}

std::string get_filename_from_user() {
    static int doc_counter = 0;
    doc_counter++;
    return "document_" + std::to_string(doc_counter) + ".doc";
}

void process_user_input(user_command const &cmd, const std::string& filename) {
    if (cmd.type == process_text) {
        print_message("在文档 " + filename + " 执行: " + cmd.text);
    }
    
    // 模拟处理时间
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
}

bool done_editing(const std::string& filename, bool force_close = false) {
    static int edit_count = 0;
    
    // 如果强制关闭或编辑次数达到某个文档特定的阈值
    if (force_close || (++edit_count > 10 && filename.find("5") != std::string::npos)) {
        edit_count = 0;
        return true;
    }
    return false;
}

void edit_document(std::string const &filename) {
    open_document_and_display_gui(filename);
    bool force_close = false;
    
    while (!done_editing(filename, force_close)) {
        user_command cmd = get_user_input(filename);
        
        if (cmd.type == open_new_document) {
            std::string const new_name = get_filename_from_user();
            print_message("从 " + filename + " 中打开新文档: " + new_name);
            std::thread t(edit_document, new_name);
            t.detach();
        } 
        else if (cmd.type == close_current_document) {
            force_close = true;
        }
        else {
            process_user_input(cmd, filename);
        }
        
        // 模拟用户操作间隔
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
    
    close_document_gui(filename);
}

int main() {
    print_message("文档编辑应用程序启动");
    
    // 打开初始文档
    edit_document("initial.doc");
    
    // 主线程等待一段时间以便观察多个文档的运行
    print_message("主线程：等待其他文档编辑线程...");
    for (int i = 0; i < 10; i++) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        
        // 显示当前活跃文档数
        std::lock_guard<std::mutex> lock(active_docs_mutex);
        print_message("当前活跃文档数: " + std::to_string(active_documents));
        
        // 如果没有活跃文档，退出
        if (active_documents == 0) {
            break;
        }
    }
    
    print_message("程序退出");
    return 0;
}

